{"componentChunkName":"component---src-templates-post-jsx","path":"/[JPA]1/","result":{"data":{"site":{"siteMetadata":{"title":"SUbbb"}},"markdownRemark":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","excerpt":"자바 ORM 표준 JPA 프로그래밍 - 김영한을 읽고 인용하고 정리하는 POST입니다. 💫 SQL을 직접 다룰 때 발생하는 문제점 \"관계형 데이터베이스는 가장 대중적이고 신뢰할 만한 안전한 데이터 저장소이다.\" 자바로 작성한 애플리케이션은 JDBC API를 사용해서 SQL을 DB에 전달해야 한다. SQL을 이용해 DB로부터 결과를 반환받아 애플리케이션에서…","html":"<p><em>[자바 ORM 표준 JPA 프로그래밍 - 김영한]을 읽고 인용하고 정리하는 POST입니다.</em></p>\n<h2>💫 SQL을 직접 다룰 때 발생하는 문제점</h2>\n<p>\"관계형 데이터베이스는 가장 대중적이고 신뢰할 만한 안전한 데이터 저장소이다.\"</p>\n<p>자바로 작성한 애플리케이션은 JDBC API를 사용해서 SQL을 DB에 전달해야 한다. SQL을 이용해 DB로부터 결과를 반환받아 애플리케이션에서 알맞게 사용한다.</p>\n<h3>➰ 반복, 반복 그리고 반복</h3>\n<p>SQL을 직접 다룰 때의 문제점을 알아봐야 한다. 이를 위해 자바와 관계형 DB를 사용한 회원 관리 기능을 개발해본다.</p>\n<p>먼저, 사용할 회원(<code class=\"language-text\">Member</code>) 객체이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class Member {\n    private String memberId;\n    private String name;\n    ...\n\n}</code>\n        </deckgo-highlight-code>\n<p>회원 객체를 DB에 관리하기 위한 회원용 DAO(Data Access Object)를 만든다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class MemberDAO {\n    public Member find(String memberId) {\n        ...\n    }\n}</code>\n        </deckgo-highlight-code>\n<p>이제 위 메소드를 이용해 회원 조회 기능을 개발하는데, 일반적인 순서는 다음과 같다.</p>\n<ol>\n<li>\n<p>회원 조회용 SQL을 작성한다.</p>\n<ul>\n<li><code class=\"language-text\">SELECT MEMBER_ID, NAME FROM MEMBER M WHERE MEMBER_ID = ?</code></li>\n</ul>\n</li>\n<li>\n<p>JDBC API를 사용해서 SQL을 실행한다.</p>\n<ul>\n<li><code class=\"language-text\">ResultSet rs = stmt.executeQuery(sql);</code></li>\n</ul>\n</li>\n<li>DB로부터 반환받은 조회 결과를 <code class=\"language-text\">Member</code> 객체로 매핑한다.</li>\n</ol>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String memberId = rs.getString(&quot;MEMBER_ID&quot;);\nString name = rs.getString(&quot;NAME&quot;);\n\nMember member = new Member();\nmember.setMemberId(memberId);\nmember.setName(name);</code>\n        </deckgo-highlight-code>\n<p>회원 조회는 완성했고, 회원 등록 기능은 다음과 같이 구현할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class MemberDAO {\n    public Member find(String memberId) {\n        ...\n    }\n\n    public void save(Member member) {\n        ...\n    }\n}</code>\n        </deckgo-highlight-code>\n<ol>\n<li>\n<p>회원 등록용 SQL을 작성한다.</p>\n<ul>\n<li><code class=\"language-text\">String sql = \"INSERT INTO MEMBER(MEMBER_ID, NAME) VALUES(?, ?)\";</code></li>\n</ul>\n</li>\n<li>회원 객체의 값을 꺼내 등록 SQL에 전달한다. </li>\n</ol>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">pstmt.setString(1, member.getMemberId());\npstmt.setString(2, member.getName());</code>\n        </deckgo-highlight-code>\n<ol start=\"3\">\n<li>\n<p>JDBC API를 사용해서 SQL을 실행한다.</p>\n<ul>\n<li><code class=\"language-text\">pstmt.executeUpdate(sql);</code></li>\n</ul>\n</li>\n</ol>\n<p>다음으로 필요한 기능은 회원 정보를 수정하고 삭제하는 기능일 것이다. 이또한 <strong>SQL을 작성하고 JDBC API를 사용해 이를 실행하는 방식</strong>으로 동일할 것이다.</p>\n<blockquote>\n<p>회원 객체를 DB가 아닌 <strong>자바 컬렉션에 보관</strong>한다면 어떻게 될까?</p>\n<ul>\n<li>컬렉션은 <code class=\"language-text\">list.add(member);</code> 한 줄로 객체를 저장할 수 있다.</li>\n</ul>\n</blockquote>\n<p>DB는 객체 구조와는 다른 <strong>데이터 중심의 구조</strong>를 가져 객체를 DB에 직접 저장하거나 조회할 수 없다.</p>\n<ul>\n<li>따라서, 개발자가 객체지향 애플리케이션과 DB 중간에서 SQL과 JDBC API를 사용해 <strong>직접 변환</strong>해줘야 한다.</li>\n<li>\n<p>여기서 <strong>문제</strong>가 발생한다.</p>\n<ul>\n<li>이러한 CRUD를 위한 코드 작성은 매우 반복적이고, 귀찮은 작업이다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ SQL에 의존적인 개발</h3>\n<p>\"회원의 연락처를 함께 저장해달라\"는 새로운 요구사항이 추가된다면 위에서 구현한 회원 객체, INSERT SQL, 회원 조회 코드, 회원 정보 수정 코드가 모두 수정되어야 한다.</p>\n<h4>등록 코드 변경</h4>\n<p>회원의 연락처를 추가하기 위해 회원 객체에 <code class=\"language-text\">tel</code> field를 추가한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public class Member {\n    private String memberId;\n    private String name;\n    private String tel;\n    ...\n\n}</code>\n        </deckgo-highlight-code>\n<p>그리고 DB에 전달할 회원 등록 SQL 또한 연락처도 함께 등록할 수 있도록 수정하고, JDBC API도 이에 맞게 수정한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String sql = &quot;INSERT INTO MEMBER(MEMBER_ID, NAME, TEL) VALUES(?, ?, ?)&quot;;\n\n...\n\npstmt.setString(3, member.getTel());</code>\n        </deckgo-highlight-code>\n<h4>조회 코드 변경</h4>\n<p>회원 조회 시 연락처 필드 또한 조회 결과로 얻을 수 있도록 SQL을 수정하고, <code class=\"language-text\">Member</code> 객체에 추가 매핑한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String sql = &quot;SELECT MEMBER_ID, NAME, TEL FROM MEMBER WHERE MEMBER_ID = ?&quot;;\n\n...\n\nString tel = rs.getString(&quot;TEL&quot;);\nmember.setTel(tel);</code>\n        </deckgo-highlight-code>\n<h4>수정 코드 변경</h4>\n<p>회원 수정 시 연락처 정보도 함께 수정될 수 있도록 UPDATE SQL과 <code class=\"language-text\">MemberDAO.update()</code> 일부를 수정한다.</p>\n<blockquote>\n<p>회원 객체를 자바 컬렉션에 보관했다면, 필드가 추가되어도 많은 코드의 수정을 요구하진 않을 것이다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">list.add(member); // 등록\nMember member = list.get(xxx); // 조회\nmember.setTel(&quot;xxx&quot;); // 수정</code>\n        </deckgo-highlight-code>\n</blockquote>\n<h4>연관된 객체</h4>\n<p>\"회원은 어떤 한 팀에 필수로 소속되어야 한다\"는 요구사항이 추가된다면 <code class=\"language-text\">Member</code> 객체에 <code class=\"language-text\">Team team</code> 필드가 추가될 것이다. </p>\n<ul>\n<li>이때, 회원 정보와 함께 연관된 팀 이름도 출력할 수 있도록 기능을 추가한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class Team {\n    ...\n    private String teamName;\n    ...\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">소속 팀: member.getTeam().getTeamName();</code>\n        </deckgo-highlight-code>\n<p>회원과 연관된 팀의 정보를 출력하기 위해서는 다음 SQL로 회원과 연관된 팀을 함께 조회해야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String sql = &quot;SELECT M.MEMBER_ID, M.NAME, M.TEL, T.TEAM_ID, T.TEAM_NAME FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID&quot;;</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p><strong>SQL의 문제점</strong></p>\n<ul>\n<li><code class=\"language-text\">Member</code> 객체가 연관된 <code class=\"language-text\">Team</code> 객체를 사용할 수 있을지 없을지는 전적으로 사용하는 SQL에 달려 있다. 하지만 이런 방식의 가장 큰 문제점은 데이터 접근 계층을 사용해서 SQL을 숨겨도, 어쩔 수 없이 DAO를 열어 어떤 SQL이 실행되는지 확인해야 한다는 점이다.</li>\n</ul>\n</blockquote>\n<p>물리적으로 SQL과 JDBC API를 데이터 접근 계층에 숨기는데는 성공했을지 몰라도, 지금처럼 논리적으로는 <strong>ENTITY와 아주 강한 의존관계</strong>를 지니고 있어 객체에 대한 새로운 요구사항이 발생할 때마다 매우 큰 보수 비용이 발생하게 된다.</p>\n<blockquote>\n<p><strong>애플리케이션에서 SQL을 직접 다룰 때 발생하는 문제점</strong></p>\n<ul>\n<li>진정한 의미의 계층 분할이 어렵다.</li>\n<li>ENTITY를 신뢰할 수 없다.</li>\n<li>SQL에 의존적인 개발을 피할 수 없다.</li>\n</ul>\n</blockquote>\n<h3>➰ JPA와 문제 해결</h3>\n<p>JPA를 사용하면 객체를 DB에 저장하고 관리할 때, SQL을 작성하는 것이 아닌 JPA가 제공하는 API를 사용하면 된다. 다음은 JPA가 제공하는 CRUD API들이다.</p>\n<h4>저장 기능</h4>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">jpa.persist(member);</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">persist()</code> 는 객체를 DB에 저장한다.</li>\n<li>JPA가 객체와 매핑정보를 보고 적절한 INSERT SQL을 생성해 DB로 전달한다.</li>\n</ul>\n<h4>조회 기능</h4>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String memberId = &quot;ID&quot;;\nMember member = jpa.find(Member.class, memberId);</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">find()</code> 는 객체 하나를 DB에서 조회한다.</li>\n<li>이또한 객체와 매핑정보를 보고 적절한 SELECT SQL을 생성해 DB로 전달하고, 결과를 <code class=\"language-text\">Member</code> 객체를 생성해 반환한다.</li>\n</ul>\n<h4>수정 기능</h4>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = jpa.find(Member.class, memberId);\nmember.setName(&quot;변경된 이름&quot;);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPA는 별도의 수정 메소드를 제공하지 않는다.</li>\n<li>대신 객체를 조회해 값을 변경하면 트랜잭션을 커밋할 때 DB에 적절한 UPDATE SQL이 전달된다.</li>\n</ul>\n<h4>연관된 객체 조회</h4>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = jpa.find(Member.class, memberId);\nTeam team = member.getTeam();</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>JPA는 연관된 객체를 사용하는 시점에 적절한 SELECT SQL을 실행한다.</p>\n<ul>\n<li>따라서 연관된 객체를 마음껏 조회할 수 있다.</li>\n</ul>\n</li>\n</ul>\n<hr>\n<h2>💫 패러다임의 불일치</h2>\n<blockquote>\n<p>객체지향 프로그래밍은 추상화, 캡슐화, 정보은닉, 상속, 다형성 등 시스템의 복잡성을 제어할 수 있는 다양한 장치들을 제공한다.</p>\n</blockquote>\n<p>비즈니스 요구사항을 정의한 도메인 모델도 객체로 모델링하면 객체지향 언어의 장점들을 활용할 수 있다.</p>\n<ul>\n<li>문제는 이 도메인 모델을 저장할 때 발생하는데, 특정 유저가 회원가입하면 회원이라는 객체를 생성한 후 <strong>메모리가 아닌 어딘가에 영구 저장</strong>해야 한다.</li>\n</ul>\n<p>객체는 <strong>속성(필드)</strong>과 <strong>기능(메소드)</strong>을 가진다. </p>\n<ul>\n<li>기능은 클래스에 정의되어 있어, 저장시에는 객체의 상태인 속성만을 저장하면 된다.</li>\n<li>\n<p>객체가 단순하면 어렵지 않지만, 부모 객체를 상속받았거나, 다른 객체를 참조하고 있다면 저장이 쉽지 않다.</p>\n<ul>\n<li>예를 들어 회원 객체가 팀 객체를 참조하고 있는 경우, 두 객체를 함께 저장해야 한다.</li>\n</ul>\n</li>\n</ul>\n<p>자바는 이런 문제를 고려해 <strong>객체를 파일로 저장하는 직렬화 기능</strong>과 <strong>저장된 파일을 객체로 복구하는 역 직렬화 기능</strong>을 지원한다.</p>\n<ul>\n<li>하지만 직렬화된 객체를 검색하기 어려운 문제가 있어 현실성이 없다.</li>\n<li>현실적인 대안은 관계형 DB에 객체를 저장하는 것인데, 관계형 DB는 <strong>데이터 중심으로 구조화</strong>되어 있고, <strong>집합적인 사고</strong>를 요구한다. 또한 추상화, 상속, 다형성 같은 개념이 없다.</li>\n</ul>\n<p>\"객체와 관계형 DB는 지향하는 목적이 서로 달라 기능과 표현 방법도 다르다. 이를 <strong>객체와 관계형 DB의 패러다임 불일치 문제</strong>라고 한다. 따라서 객체 구조를 테이블 구조에 저장하는 데는 당연히 한계가 존재한다.\"</p>\n<ul>\n<li>이러한 패러다임 불일치 문제를 해결하기 위해 중간에 있는 개발자는 너무 많은 시간과 코드를 소비한다.</li>\n<li>아래는 이로 인해 발생하는 문제들을 구체적으로 다룬다.</li>\n</ul>\n<h3>➰ 상속</h3>\n<p>\"객체는 상속이라는 기능을 가지고 있지만, 테이블은 가지고 있지 않다.\" (일부 DB가 지원하는 상속 기능은 객체의 상속과는 다르다.)</p>\n<ul>\n<li>\n<p>DB 모델링에서 다루는 슈퍼타입 서브타입 관계를 사용하여 객체 상속과 유사한 형태로 테이블을 설계할 수는 있다.</p>\n<ul>\n<li>테이블의 특정 컬럼을 사용해서 어떤 자식 테이블과 관계가 있는지 정의하는 방식</li>\n</ul>\n</li>\n</ul>\n<p>객체 모델 코드는 다음과 같다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">abstract class Item {\n    Long id;\n    String name;\n    int price;\n}\n\nclass Album extends Item {\n    String artist;\n}\n\nclass Movie extends Item {\n    String director;\n    String actor;\n}\n\nclass Book extends Item {\n    String author;\n    String isbn;\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li><code class=\"language-text\">Album</code> 객체를 저장하기 위해서는 객체를 분해해서 두 개의 SQL을 작성해야 한다. (<code class=\"language-text\">ITEM</code> , <code class=\"language-text\">ALBUM</code>)</li>\n<li>JDBC API를 사용해 부모 객체에서 부모 데이터만 꺼내서 <code class=\"language-text\">ITEM</code> 용 INSERT SQL을 작성하고, 자식 객체에서 자식 데이터만 꺼내서 <code class=\"language-text\">ALBUM</code> 용 INSERT SQL을 작성하는 것은 매우 비효율적이다.</li>\n<li>조회하는 것 또한 두 테이블을 조인하고, 결과를 객체로 매핑하는 작업이 필요하다.</li>\n</ul>\n<blockquote>\n<p>💨 <strong>모두 패러다임의 불일치를 해결하기 위해 소모되는 비용이다.</strong></p>\n</blockquote>\n<blockquote>\n<p>만약 <strong>자바 컬렉션</strong>을 사용해 해당 객체들을 보관한다면 부모 자식 관계나 타입에 상관없이 아래와 같은 코드로 가능하다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">list.add(album);\nlist.add(movie);\n\nAlbum album = list.get(albumId);</code>\n        </deckgo-highlight-code>\n</blockquote>\n<h4>JPA와 상속</h4>\n<p>JPA는 상속과 관련된 패러다임의 불일치 문제를 마치 <strong>자바 컬렉션에 객체를 저장하듯이 JPA에게 객체를 저장하게 함</strong>으로써 해결해준다. </p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// Item을 상속한 Album객체를 저장한다.\njpa.persist(album);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>이때, JPA는 두 SQL(<code class=\"language-text\">ITEM</code> INSERT, <code class=\"language-text\">ALBUM</code> INSERT)을 실행해 객체를 두 테이블에 나눠 저장한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">// Album 객체를 조회한다.\nString albumId = &quot;id100&quot;;\nAlbum album = jpa.find(Album.class, albumId);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>JPA는 두 테이블을 조인해서 필요한 결과를 가져와 반환한다.</li>\n</ul>\n<h3>➰ 연관관계</h3>\n<p><strong>객체는 참조</strong>를 사용해 다른 객체와 연관관계를 가지고 이를 통해 연관된 객체를 조회하는 반면, <strong>테이블은 외래 키(Foreign Key)</strong>를 사용해 다른 테이블과 연관관계를 가지고 조인을 사용해 연관된 테이블을 조회한다.</p>\n<ul>\n<li>이 둘 간의 패러다임 불일치는 매우 극복이 어렵다.</li>\n</ul>\n<p><code class=\"language-text\">Member</code> 객체는 <code class=\"language-text\">Member.team</code> 필드에 <code class=\"language-text\">Team</code> 객체의 참조를 보관해 연관관계를 가진다. 따라서 <code class=\"language-text\">member.getTeam()</code> 으로 연관된 <code class=\"language-text\">Team</code> 을 조회할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class Member {\n    Team team;\n    ...\n\n    Team getTeam() {\n        return team;\n    }\n}\n\nclass Team {\n    ...\n}</code>\n        </deckgo-highlight-code>\n<p><code class=\"language-text\">MEMBER</code> 테이블은 <code class=\"language-text\">MEMBER.TEAM_ID</code> 외래 키 컬럼을 사용해 <code class=\"language-text\">TEAM</code> 테이블과 연관관계를 가진다. 이 키를 사용해 테이블을 조인하여 연관된 <code class=\"language-text\">TEAM</code> 을 조회할 수 있다.</p>\n<deckgo-highlight-code language=\"sql\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">SELECT M.*, T.* FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID</code>\n        </deckgo-highlight-code>\n<p>여기서, <strong>객체는 참조가 있는 방향으로만 조회가 가능</strong>하다. 즉 <code class=\"language-text\">team.getMember()</code> 는 불가능하다. 하지만 <strong>테이블은 외래 키 하나로 양방향으로 조회가 가능</strong>하다.</p>\n<h4>객체를 테이블에 맞추어 모델링</h4>\n<p>객체와 테이블의 차이를 알아보기 위해 객체를 단순히 테이블에 맞춰 모델링한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class Member {\n    String id; // MEMBER_ID\n    Long teamId; // TEAM_ID\n    String userName; // USERNAME\n}\n\nclass Team {\n    Long id; // TEAM_ID\n    String name; // NAME\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>위와 같이 객체를 테이블에 맞춰 모델링함으로써 객체를 테이블에 저장하거나 조회하는 것은 편리해졌다.</li>\n<li>\n<p>하지만 외래 키 값을 그대로 보관하는 <code class=\"language-text\">teamId</code> 필드는 문제가 있다.</p>\n<ul>\n<li>관계형 DB의 경우, <strong>\"조인\"</strong> 기능이 있어 외래 키 값을 그대로 보관해도 상관없지만, <strong>객체는 연관된 객체의 참조를 보관</strong>해야 참조를 통해 연관된 객체를 조회할 수 있다.</li>\n</ul>\n</li>\n</ul>\n<blockquote>\n<p><strong>외래 키까지 테이블에 맞춘 모델링 방식을 사용</strong>하게 되면</p>\n<ul>\n<li>결국 참조를 통해 연관된 객체를 조회할 수가 없어지고, </li>\n<li>객체지향의 특징을 잃어버리게 된다.</li>\n</ul>\n</blockquote>\n<h4>객체지향 모델링</h4>\n<p>위에서 테이블에 맞춘 모델링 방식의 문제점(객체지향의 특징을 소실)을 이해했다. 이제 참조를 통한 연관관계를 가지도록 모델링한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class Member {\n    String id; // MEMBER_ID\n    Team team; // 참조로 연관관계를 가짐\n    String userName;\n\n    Team getTeam() {\n        return team;\n    }\n}\n\nclass Team {\n    Long id; // TEAM_ID - PK\n    String name; // NAME\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>연관된 <code class=\"language-text\">Team</code> 의 참조를 보관함으로써, <code class=\"language-text\">member.getTeam()</code> 으로 연관된 객체를 조회할 수 있다.</li>\n<li>\n<p>하지만 이런 객체지향 모델링은 객체를 테이블에 저장하거나 조회하는 데에 어려움이 있다. </p>\n<ul>\n<li><strong>객체와 테이블의 연관관계를 맺는 방식의 차이</strong>(필드와 외래 키)때문인데, 이는 결국 개발자가 중간다리역할을 수행해야 해결이 가능했다.</li>\n</ul>\n</li>\n</ul>\n<p><strong>저장</strong></p>\n<ul>\n<li>객체를 DB에 저장하기 위해 <code class=\"language-text\">team</code> 필드를 <code class=\"language-text\">TEAM_ID</code> 외래 키 값으로 변환한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member.getId(); // MEMBER_ID - PK에 저장\nmember.getTeam().getId(); // TEAM_ID - FK에 저장, INSERT SQL에 사용\nmember.getUserName(); // USERNAME 컬럼에 저장</code>\n        </deckgo-highlight-code>\n<p><strong>조회</strong></p>\n<ul>\n<li><code class=\"language-text\">TEAM_ID</code> 외래 키 값을 <code class=\"language-text\">Member</code> 객체의 <code class=\"language-text\">team</code> 참조로 변환한다.</li>\n<li>먼저 <code class=\"language-text\">MEMBER</code> 와 <code class=\"language-text\">TEAM</code> 을 조회하고, 이 결과로 객체를 생성해 연관관계를 설정하고 반환한다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">public Member find(String memberId) {\n    // SQL 실행\n    ...\n    Member member = new Member();\n    ...\n\n    // DB에서 조회한 회원 관련 정보를 모두 입력\n    Team team = new Team();\n    ...\n    // DB에서 조회한 팀 관련 정보를 모두 입력\n\n    // 회원과 팀 관계 설정\n    member.setTeam(team);\n    return member;\n}</code>\n        </deckgo-highlight-code>\n<blockquote>\n<p>매번 언급하듯, 자바 컬렉션에 저장한다면 이러한 패러다임 불일치 해결을 위한 비용은 소모되지 않는다.</p>\n</blockquote>\n<h4>JPA와 연관관계</h4>\n<p>\"JPA는 연관관계와 관련된 패러다임의 불일치 문제를 해결해준다.\"</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member.setTeam(team); // 회원과 팀 관계 설정\njpa.persist(member); // 회원과 연관관계 함께 저장</code>\n        </deckgo-highlight-code>\n<ul>\n<li>개발자는 그저 관계를 설정하고 객체를 저장하기만 하면 된다.</li>\n<li>JPA는 위에서의 중간다리역할을 수행해 적절한 SQL을 DB에 전달하고, 적절하게 반환해준다.</li>\n</ul>\n<h3>➰ 객체 그래프 탐색</h3>\n<p>객체에서 회원이 소속된 팀 조회 시 참조를 사용하는 것을 <strong>객체 그래프 탐색</strong>이라고 한다. 객체 연관관계가 연속적으로 이어져있는 경우 아래 코드와 같이 마음껏 객체 그래프를 탐색할 수 있어야 한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member.getOrder().getOrderItem();</code>\n        </deckgo-highlight-code>\n<p>하지만 DB를 사용하는 경우, <code class=\"language-text\">SELECT M.*, T.* FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID</code> 를 실행해서 회원과 팀에 대한 데이터는 조회가 가능하지만, 다른 객체 그래프는 데이터가 없어 탐색할 수 없게 된다. (<code class=\"language-text\">member.getOrder();</code> 의 결과는 <code class=\"language-text\">null</code>)</p>\n<p><strong>\"SQL을 직접 다루면 처음 실행하는 SQL에 따라 객체 그래프의 탐색 영역이 제한된다.\"</strong> </p>\n<ul>\n<li>이는 비즈니스 로직에 따라 사용하는 객체 그래프가 다른데 언제 끊어질지 모를 객체 그래프를 함부로 탐색할 수는 없기에 객체지향 개발자에겐 매우 큰 제약이다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class MemberService {\n    ...\n    public void process() {\n        Member member = memberDAO.find(memberId);\n        member.getItem(); // member -&gt; team 객체 그래프 탐색이 가능한가?\n        member.getOrder().getDelivery(); // ???\n    }\n}</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>위 예제는 <code class=\"language-text\">memberDAO</code> 를 통해 <code class=\"language-text\">member</code> 객체를 조회했지만, 이 객체와 연관된 객체 방향으로 객체 그래프를 탐색할 수 있을지는 예측할 수 없다.</p>\n<ul>\n<li>탐색 가능 여부의 확인을 위해서는 <code class=\"language-text\">DAO</code> 의 SQL을 직접 확인하는 수밖에 없다.</li>\n<li>이는 이전에도 다룬 \"ENTITY가 SQL에 논리적으로 종속\"되기에 발생하는 문제이다.</li>\n<li>그렇다고 연관된 모든 객체 그래프를 DB에서 조회해서 메모리에 올려두는 것은 현실성이 없기에 <code class=\"language-text\">getMemberWithTeam()</code> , <code class=\"language-text\">getMemberWithOrderWithDelivery()</code> 와 같이 경우에 따른 메소드를 여러 개 만들어 둬야 한다.</li>\n</ul>\n</li>\n</ul>\n<h4>JPA와 객체 그래프 탐색</h4>\n<p>JPA를 사용하면 객체 그래프를 마음껏 탐색할 수 있다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">member.getOrder().getOrderItem();</code>\n        </deckgo-highlight-code>\n<p>이전에도 언급했듯, <strong>JPA는 연관된 객체를 사용하는 시점에 적절한 SQL을 실행</strong>한다.</p>\n<ul>\n<li>즉, 연관된 객체를 신뢰하고 마음껏 조회할 수 있다.</li>\n<li>이는 실제 객체를 사용하는 시점까지 DB 조회를 미룬다고 하여 <strong>\"지연 로딩\"</strong>이라고 한다.</li>\n</ul>\n<p><strong>지연 로딩</strong></p>\n<ul>\n<li><strong>JPA는 지연 로딩을 투명(transparent)하게 처리</strong>한다. 즉, JPA와 관련된 어떤 추가적인 코드도 필요하지 않다.</li>\n</ul>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">Member member = jpa.find(Member.class, memberId);\n\nOrder order = member.getOrder();\norder.getOrderDate(); // Order를 사용하는 시점에 SELECT ORDER SQL</code>\n        </deckgo-highlight-code>\n<ul>\n<li>실제 <code class=\"language-text\">Order</code> 객체를 사용하는 시점에 JPA는 DB에서 테이블을 조회하게 된다.</li>\n</ul>\n<h3>➰ 비교</h3>\n<p>DB는 <strong>기본 키의 값</strong>으로 각 행을 구분한다. 하지만 객체는 <strong>동일성 비교</strong>와 <strong>동등성 비교</strong>라는 두 가지 비교 방법이 있다.</p>\n<ul>\n<li>동일성 비교는 <code class=\"language-text\">==</code> 비교이다. 객체 인스턴스의 주소 값을 비교한다.</li>\n<li>동등성 비교는 <code class=\"language-text\">equals()</code> 메소드를 사용해서 객체 내부의 값을 비교한다.</li>\n</ul>\n<blockquote>\n<p>여기서 하고 싶은 말은, 테이블의 행을 구분하는 방법과 객체를 구분하는 방법에는 차이가 있다는 것이다.</p>\n</blockquote>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">class MemberDAO {\n    public Member getMember(String memberId) {\n        String sql = &quot;SELECT * FROM MEMBER WHERE MEMBER_ID = ?&quot;;\n        ...\n\n        // JDBC API, SQL 실행\n\n        return new Member(...);\n    }\n}</code>\n        </deckgo-highlight-code>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String memberId = &quot;100&quot;;\nMember member1 = memberDAO.getMember(memberId);\nMember member2 = memberDAO.getMember(memberId);\n\nmember1 == member2; // 다르다!</code>\n        </deckgo-highlight-code>\n<ul>\n<li>\n<p>같은 기본 키 값으로 회원 객체를 두 번 조회했다. </p>\n<ul>\n<li>조회한 결과를 동일성 비교하면, <code class=\"language-text\">false</code> 가 반환된다.</li>\n<li>이는 같은 DB 행에서 조회했지만, 객체 측면에서 볼 때, <strong>둘은 서로 다른 인스턴스</strong>이기 때문이다. (<code class=\"language-text\">getMember()</code> 호출 시, <code class=\"language-text\">new Member()</code> 로 인스턴스를 매번 새로 생성)</li>\n</ul>\n</li>\n<li>DB에 같은 행을 조회했지만 동일성 비교는 실패한다. 하지만 이 또한 컬렉션에 보관했다면 동일성 비교에 성공했을 것이다.</li>\n</ul>\n<blockquote>\n<p>이러한 패러다임의 불일치 문제를 해결하기 위해 DB의 같은 행을 조회할 때마다 같은 인스턴스를 반환되도록 하는 것은 쉽지 않다. 거기에 트랜잭션까지 고려한다면 더 골치가 아프다.</p>\n</blockquote>\n<h4>JPA와 비교</h4>\n<p>JPA는 같은 트랜잭션일 떄 같은 객체가 조회되는 것을 보장한다. 그러므로 위 예제에서 <code class=\"language-text\">memberDAO.getMember()</code> 가 아닌 <code class=\"language-text\">jpa.find()</code> 로 두 인스턴스의 동일성 비교가 성공한다.</p>\n<h3>➰ 정리</h3>\n<p>JPA는 객체 모델과 관계형 DB 모델이 각자 지향하는 패러다임의 불일치 문제를 해결해줌으로써, 개발자가 너무 많은 시간과 코드를 소비하지않도록 돕는다.</p>\n<hr>\n<h2>💫 JPA란 무엇일까?</h2>\n<p>JPA(Java Persistence API)는 자바 진영의 ORM 기술 표준이다. 어는 자바 애플리케이션과 JDBC 사이에서 동작한다.</p>\n<p>그럼 ORM은 무엇일까? </p>\n<ul>\n<li><strong>Object Relational Mapping</strong>이라는 이름 그대로 객체와 관계형 DB를 매핑한다. </li>\n</ul>\n<p>ORM 프레임워크는 객체와 테이블을 매핑해 패러다임의 불일치 문제를 해결해준다. 즉 INSERT SQL을 직접 작성하는 것이 아닌 객체를 마치 \"자바 컬렉션에 저장하듯 ORM 프레임워크에 저장\"하면 된다.</p>\n<p><code class=\"language-text\">MemberDAO</code> 에서 <code class=\"language-text\">Entity Object</code> 를 <code class=\"language-text\">PERSIST</code>(저장) 하면 JPA는,</p>\n<ul>\n<li>해당 ENTITY를 분석하고</li>\n<li>INSERT SQL을 생성하고</li>\n<li>JDBC API를 사용함으로써</li>\n</ul>\n<p><strong>패러다임의 불일치 문제를 해결</strong>한다.</p>\n<p><code class=\"language-text\">FIND</code>(조회)할 때 역시</p>\n<ul>\n<li>SELECT SQL을 생성하고</li>\n<li>JDBC API를 사용해</li>\n<li>반환된 결과를 ResultSet에 매핑함으로써</li>\n</ul>\n<p><strong>패러다임의 불일치 문제를 해결</strong>한다.</p>\n<p>이는 단순히 SQL을 개발자 대신 생성해 DB에 전달하는 것뿐 아닌 다양한 패러다임의 불일치 문제들도 해결해준다. </p>\n<ul>\n<li>따라서, 객체 측면에서는 정교한 객체 모델링이 가능해졌고, </li>\n<li>관계형 DB는 DB에 맞도록 모델링을 할 수 있다.</li>\n<li>그리고 매핑 방법만 ORM 프레임워크에 전달하면 된다.</li>\n</ul>\n<p>객체지향 언어에 따라 다양한 ORM 프레임워크들이 존재한다. 그중 Hibernate 프레임워크는 거의 대부분의 패러다임 불일치 문제를 해주는 프레임워크로, 가장 많이 사용된다.</p>\n<h3>➰ JPA 소개</h3>\n<p>과거 <strong>엔터프라이즈 자바 빈즈(EJB)</strong>라는 기술 표준이 있었다. 내부에는 엔티티 빈이라는 ORM 기술도 포함되어 있었는데, 너무 복잡하고 기술 성숙도도 떨어졌으며 자바 엔터프라이즈(J2EE) 애플리케이션 서버에서만 동작한다는 단점이 있었다.</p>\n<p>이때, Hibernate 오픈소스 ORM 프레임워크가 등장했다. 이는 매우 가볍고 실용적이며 기술 성숙도 또한 높아 이를 기반으로 새로운 자바 ORM 기술 표준을 만들었고, 이것이 바로 JPA이다.</p>\n<blockquote>\n<p><strong>JPA는 자바 ORM 기술에 대한 API 표준 명세이다.</strong></p>\n</blockquote>\n<ul>\n<li>\n<p>인터페이스를 모아둔 것으로, JPA를 구현한 ORM 프레임워크를 선택해야 JPA를 사용할 수 있다.</p>\n<ul>\n<li>현재 JPA 2.1을 구현한 ORM 프레임워크는 Hibernate, EclipseLink, DataNucleus가 있다.</li>\n</ul>\n</li>\n</ul>\n<h3>➰ 왜 JPA를 사용해야 하는가?</h3>\n<p>여러가지 이유가 있다. 하나씩 살펴보도록 한다.</p>\n<h4>생산성</h4>\n<p>위에서 여러 번 언급했듯, 자바 컬렉션에 객체를 저장하는 것과 같은 코드 간결성을 얻을 수 있다. 지루하고 반복적인 CRUD용 SQL을 개발자가 직접 작성하지 않아도 되고, DDL문 또한 자동으로 생성해주기도 한다.</p>\n<blockquote>\n<p>DB 설계 중심의 패러다임을 객체 설계 중심으로 역전시킬 수 있다.</p>\n</blockquote>\n<h4>유지보수</h4>\n<p>SQL을 직접 다루게 되면, 이전에도 언급했듯 ENTITY에 필드를 하나만 추가해도 관련된 SQL과 결과를 매핑하기 위한 JDBC API 코드를 모두 수정해야 한다. 하지만 JPA는 이런 모든 과정을 대신 처리하기에 결과적으로 유지보수해야하는 코드의 수가 줄어드는 이점을 얻을 수 있다.</p>\n<h4>패러다임의 불일치 해결</h4>\n<p>JPA는 지겹도록 언급한 상속, 연관관계, 객체 그래프 탐색, 비교하기와 같은 패러다임의 불일치 문제를 해결해준다.</p>\n<h4>성능</h4>\n<p>애플리케이션과 DB 사이에 계층이 하나 더 있으면 최적화 관점에서 시도해 볼 수 있는 것들이 많다. JPA는 이 중간 계층으로서, 다양한 성능 최적화 기회를 제공한다.</p>\n<deckgo-highlight-code language=\"java\" terminal=\"carbon\" theme=\"a11y-dark\" line-numbers=\"true\"  >\n          <code slot=\"code\">String memberId = &quot;helloId&quot;;\nMember member1 = jpa.find(memberId);\nMember member2 = jpa.find(memberId);</code>\n        </deckgo-highlight-code>\n<ul>\n<li>위 예시는 같은 트랜잭션 안에서 같은 회원을 두 번 조회하는 코드인데, JDBC API를 사용했다면 SELECT SQL을 사용해 <strong>DB와 두 번 통신</strong>했을 것이다.</li>\n<li>하지만 JPA를 사용하면, SELECT SQL을 한 번만 DB에 전달하고, 두번째 조회는 <strong>이미 조회한 회원 객체를 재사용</strong>하여 최적화를 제공할 수 있다.</li>\n</ul>\n<h4>데이터 접근 추상화와 벤더 독립성</h4>\n<p>관계형 DB는 같은 기능이라도 벤더마다 사용법이 다른 경우가 많다.</p>\n<ul>\n<li>페이징 처리는 DB마다 달라서 사용법을 각각 배워야 한다.</li>\n</ul>\n<p>결국, 애플리케이션은 처음 선택한 DB 기술에 종속되고 다른 DB로 변경이 매우 어려워진다.</p>\n<p>JPA는 애플리케이션과 DB 사이에 <strong>추상화된 데이터 접근 계층을 제공</strong>해 특정 DB 기술에 종속되지 않도록 한다.</p>\n<ul>\n<li>DB를 변경하기 위해서는 JPA에게 이를 알려주기만 하면 된다.</li>\n</ul>\n<h4>표준</h4>\n<p>JPA는 자바 진영의 ORM 기술 표준으로서, 이를 사용하면 다른 구현 기술로 손쉽게 변경할 수 있다.</p>\n<blockquote>\n<blockquote>\n<p>\"<strong>JPA가 어려운 근본적인 이유는 ORM이 객체지향과 관계형 DB라는 두 기둥 위에 있기 때문입니다.</strong>\"</p>\n</blockquote>\n</blockquote>\n<h2>📕 출처</h2>\n<p><strong>자바 ORM 표준 JPA 프로그래밍</strong> - 김영한</p>","frontmatter":{"title":"📚 1. JPA 소개","date":"March 04, 2022","update":"March 04, 2022","tags":["Java","JPA","SpringBoot"],"series":"📚 ORM 표준 JPA"},"fields":{"slug":"/[JPA]1/","readingTime":{"minutes":33.33}}},"seriesList":{"edges":[{"node":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","fields":{"slug":"/[JPA]1/"},"frontmatter":{"title":"📚 1. JPA 소개"}}},{"node":{"id":"f86fa867-f096-52ce-854a-ef00e49ebcdb","fields":{"slug":"/[JPA]2/"},"frontmatter":{"title":"📚 2. JPA 시작"}}},{"node":{"id":"ffb8392d-d300-51c1-8e71-a8943ef4b58d","fields":{"slug":"/[JPA]3/"},"frontmatter":{"title":"📚 3. 영속성 관리"}}},{"node":{"id":"f45d0c27-c0da-5191-8c86-2aef34b75f27","fields":{"slug":"/[JPA]4/"},"frontmatter":{"title":"📚 4. 엔티티 매핑"}}},{"node":{"id":"c710307c-927c-5c1b-80fb-c45a4ff20616","fields":{"slug":"/[JPA]5/"},"frontmatter":{"title":"📚 5. 연관관계 매핑 기초"}}},{"node":{"id":"24c890e9-eebe-56bf-9db2-8660dcb3b783","fields":{"slug":"/[JPA]6/"},"frontmatter":{"title":"📚 6. 다양한 연관관계 매핑"}}},{"node":{"id":"26e75089-52ac-5b50-98c9-c2806068b034","fields":{"slug":"/[JPA]7/"},"frontmatter":{"title":"📚 7. 고급 매핑"}}},{"node":{"id":"ac8c493e-a661-53a5-989d-b84fcb728ed1","fields":{"slug":"/[JPA]8/"},"frontmatter":{"title":"📚 8. 프록시와 연관관계 관리"}}},{"node":{"id":"5003d7a8-381f-550d-aecd-28caba14aba9","fields":{"slug":"/[JPA]9/"},"frontmatter":{"title":"📚 9. 값 타입"}}},{"node":{"id":"a41dc548-d976-533a-a680-96e86a627d35","fields":{"slug":"/[JPA]10/"},"frontmatter":{"title":"📚 10. 객체지향 쿼리 언어"}}},{"node":{"id":"4ef1a134-ac1d-5e69-9f85-7c1b5d7a8244","fields":{"slug":"/[JPA]11/"},"frontmatter":{"title":"📚 11. 웹 애플리케이션 제작"}}},{"node":{"id":"1a74ae89-3758-5cb9-938c-b8238d176c8c","fields":{"slug":"/[JPA]12/"},"frontmatter":{"title":"📚 12. 스프링 데이터 JPA"}}},{"node":{"id":"5900f638-1417-5a4a-a147-a228540a920b","fields":{"slug":"/[JPA]13/"},"frontmatter":{"title":"📚 13. 웹 애플리케이션과 영속성 관리"}}},{"node":{"id":"5f07d9ea-eadc-54ea-90b2-efe93297170f","fields":{"slug":"/[JPA]14/"},"frontmatter":{"title":"📚 14. 컬렉션과 부가 기능"}}},{"node":{"id":"838bd515-9bd3-5d4b-8f49-723d3f55688c","fields":{"slug":"/[JPA]15/"},"frontmatter":{"title":"📚 15. 고급 주제와 성능 최적화"}}},{"node":{"id":"1f449b33-36ba-58f9-915f-be058ee6ba3e","fields":{"slug":"/[JPA]16/"},"frontmatter":{"title":"📚 16. 트랜잭션과 락, 2차 캐시"}}}]},"previous":{"fields":{"slug":"/[BOJ]2437/"},"frontmatter":{"title":"👩‍💻 2437. 저울"}},"next":{"fields":{"slug":"/[JPA]2/"},"frontmatter":{"title":"📚 2. JPA 시작"}}},"pageContext":{"id":"66d0397b-0a88-53f8-9e40-01878853acdd","series":"📚 ORM 표준 JPA","previousPostId":"8d77114d-fc6e-5de2-a3ca-c3b250425a56","nextPostId":"f86fa867-f096-52ce-854a-ef00e49ebcdb"}},"staticQueryHashes":[]}